<template>
	<view class="knowledge-container">
		<!-- 下拉刷新组件 -->
		<scroll-view scroll-y class="scroll-view" :refresher-enabled="true" :refresher-triggered="isRefreshing"
			@refresherrefresh="onRefresh" @refresherrestore="onRestore">
			<!-- 知识库选择器 -->
			<knowledge-header @search="onSearch" @upload="showUploadOptions" />
			<!-- 文件列表 -->
			<file-list :files="files" :is-multi-select="isMultiSelect" :selected-ids="selectedFileIds"
				@delete="showDeleteConfirm" @select="handleFileSelect" @enableMultiSelect="enableMultiSelectWithFile"
				@open="openFile" />
		</scroll-view>

		<!-- 底部提问区域 -->
		<question-bar @click="goToQuestion" v-if="!isMultiSelect" />

		<!-- 底部多选操作栏 -->
		<view class="multi-select-bar" v-if="isMultiSelect">
			<view class="selected-count">已选择 {{ selectedFileIds.length }} 项</view>
			<view class="action-btns">
				<button class="cancel-btn" @click="cancelMultiSelect">取消</button>
				<button class="delete-btn" @click="showBatchDeleteConfirm">删除</button>
			</view>
		</view>

		<!-- 上传选项弹窗 -->
		<file-upload-dialog :show="showUploadSheet" :options="uploadOptions" @update:show="val => showUploadSheet = val"
			@select="handleUploadAction" />

		<!-- 微信授权登录弹窗 -->
		<wechat-login-popup :show="showLoginPopup" @update:show="val => showLoginPopup = val" @login="handleLogin"
			@cancel="showLoginPopup = false" />
	</view>
</template>

<script>
	import KnowledgeHeader from '@/components/knowledge/KnowledgeHeader.vue'
	import FileList from '@/components/knowledge/FileList.vue'
	import QuestionBar from '@/components/knowledge/QuestionBar.vue'
	import FileUploadDialog from '@/components/knowledge/FileUploadDialog.vue'
	import WechatLoginPopup from '@/components/common/WechatLoginPopup.vue'
	import {
		checkLoginStatus,
		handleWechatLogin
	} from '@/utils/authService.js'
	import api from '@/api/index.js'
	import request from '@/utils/request.js'

	export default {
		components: {
			KnowledgeHeader,
			FileList,
			QuestionBar,
			FileUploadDialog,
			WechatLoginPopup
		},
		data() {
			return {
				isRefreshing: false,
				files: [],
				showUploadSheet: false,
				uploadOptions: [{
						text: '微信文件',
						icon: 'chat'
					},
					{
						text: '本地相册',
						icon: 'photo'
					}
				],
				isLoggedIn: false, // 登录状态
				showLoginPopup: false, // 是否显示登录弹窗
				userInfo: null, // 用户信息
				refreshDebounceTimer: null, // 用于防抖刷新的定时器
				selectedFileIds: [], // 选中的文件ID数组，用于批量删除
				isMultiSelect: false, // 是否处于多选模式

				pagination: {
					page: 1,
					page_size: 20,
					total: 0
				}
			}
		},
		onLoad() {
			console.log('onLoad');

			// 获取登录状态
			this.initLoginStatus()
		},
		beforeDestroy() {
			// 清除定时器，避免内存泄漏
			if (this.refreshDebounceTimer) {
				clearTimeout(this.refreshDebounceTimer);
				this.refreshDebounceTimer = null;
			}
		},
		methods: {
			// 初始化登录状态
			initLoginStatus() {
				console.log('Initializing login status...')

				// 调试时可以清除登录状态
				// uni.removeStorageSync('userInfo')

				const authInfo = checkLoginStatus()
				this.isLoggedIn = authInfo.isLoggedIn
				this.userInfo = authInfo.userInfo

				// 只有在登录状态下才加载文件列表
				if (this.isLoggedIn) {
					this.loadFileList()
				} else {
					console.log('用户未登录，不加载文件列表')
					// 未登录状态下清空文件列表
					this.files = []
				}
			},
			// 加载文件列表
			async loadFileList() {
				try {
					uni.showLoading({
						title: '加载中...'
					});

					// 构建API请求参数
					const params = {
						page: this.pagination.page,
						page_size: this.pagination.page_size,
						datasetId: uni.getStorageSync('datasetId'), // 数据集ID
					};

					// 调用API获取文档列表
					const result = await api.datasets.getDocuments(params);

					if (result && result.docs) {
						// 格式化文档数据为组件需要的格式
						this.files = result.docs.map(doc => ({
							id: doc.id,
							name: doc.name || '未命名文档',
							type: this.getFileTypeByName(doc.name),
							progress: doc.progress,
							preview: doc.icon || '/static/images/doc-preview.png',
							// 保存原始文档信息，以备后续使用
							document: doc
						}));

						// 更新分页信息
						this.pagination.total = result.total || 0;
					} else {
						this.files = [];
					}

					uni.hideLoading();
				} catch (error) {
					console.error('获取文件列表失败', error);
					uni.hideLoading();
					uni.showToast({
						title: '获取文件列表失败',
						icon: 'none'
					});
				}
			},
			// 根据文件名判断文件类型
			getFileTypeByName(fileName) {
				if (!fileName) return '未知文件';

				const extension = fileName.substring(fileName.lastIndexOf('.')).toLowerCase();
				switch (extension) {
					case '.doc':
					case '.docx':
						return 'Word文件';
					case '.pdf':
						return 'PDF文件';
					case '.txt':
						return '文本文件';
					default:
						return '文档';
				}
			},
			// 下拉刷新处理
			async onRefresh() {
				this.isRefreshing = true;
				try {
					// 检查用户是否已登录
					if (this.isLoggedIn) {
						// 重置到第一页
						this.pagination.page = 1;
						await this.loadFileList();
					} else {
						console.log('用户未登录，下拉刷新不获取文件列表');
						// 提示用户需要登录
						uni.showToast({
							title: '请先登录后查看文件',
							icon: 'none'
						});
						// 确保未登录状态下也能结束刷新状态
						setTimeout(() => {
							this.isRefreshing = false;
						}, 500);
					}
				} finally {
					// finally块有时可能执行不及时，确保状态回归
					setTimeout(() => {
						if (this.isRefreshing) {
							this.isRefreshing = false;
						}
					}, 1000);
				}
			},
			onRestore() {
				// 下拉刷新复位
				console.log('刷新复位')
			},
			// 刷新文件列表
			async refreshFileList() {
				// 确保只在登录状态下刷新文件列表
				if (this.isLoggedIn) {
					this.pagination.page = 1; // 重置到第一页
					await this.loadFileList();
				}
			},
			// 搜索
			onSearch() {
				// 检查登录状态
				if (!this.isLoggedIn) {
					// 未登录，显示登录弹窗
					this.showLoginPopup = true;
					return;
				}

				// 已登录，执行搜索功能
				uni.showToast({
					title: '搜索功能待实现',
					icon: 'none'
				})
			},
			// 处理提问按钮点击
			goToQuestion(event) {
				// 检查登录状态
				if (!this.isLoggedIn) {
					// 未登录，显示登录弹窗
					this.showLoginPopup = true;
					return;
				}
				const mode = event?.mode || 'kb'
				// 跳转到 aiChat 页面，并传递参数
				uni.navigateTo({
					url: `/pages/index/aiChat?mode=${mode}`
				})
			},
			// 处理登录
			async handleLogin(userInfo) {
				console.log('handleLogin', userInfo);

				try {
					const loginResult = await handleWechatLogin(userInfo)
					this.isLoggedIn = true
					this.userInfo = loginResult.userInfo

					// 关闭登录弹窗
					this.showLoginPopup = false;

					// 登录成功后加载文件列表
					this.loadFileList()
				} catch (error) {
					console.error('登录失败', error)
				}
			},
			// 显示上传选项
			showUploadOptions() {
				// 检查登录状态
				if (!this.isLoggedIn) {
					// 未登录，显示登录弹窗
					this.showLoginPopup = true;
					return;
				}

				// 已登录，显示上传选项
				this.showUploadSheet = true;
				console.log(this.showUploadSheet);
			},
			// 处理上传选项
			handleUploadAction(index) {
				if (index === 0) {
					// 上传文档
					this.chooseAndUploadFile('doc')
				} else if (index === 1) {
					// 上传图片
					this.chooseAndUploadFile('image')
				}
			},
			// 选择并上传文件
			chooseAndUploadFile(type) {
				// 判断是文档还是图片
				if (type === 'doc' || type === 0) {
					// 使用微信聊天文件选择器选择文档
					// 微信小程序中，用户需要先将文件发送到聊天，然后从聊天记录中选择
					uni.chooseMessageFile({
						count: 10, // 最多选择10个文件
						type: 'file', // 选择非图片类型的文件
						extension: ['.doc', '.docx', '.pdf', '.txt', '.xls', '.xlsx', '.ppt', '.pptx'], // 文件类型限制
						success: (res) => {
							if (res.tempFiles && res.tempFiles.length > 0) {
								// 显示选择的文件数量
								uni.showToast({
									title: `已选择${res.tempFiles.length}个文件`,
									icon: 'none',
									duration: 1500
								});

								// 遍历处理每个文件
								res.tempFiles.forEach(fileInfo => {
									console.log('选择的文件:', fileInfo);

									// 检查文件大小，限制为20MB
									if (fileInfo.size > 20 * 1024 * 1024) {
										uni.showToast({
											title: `文件"${fileInfo.name}"大小超过20MB，已跳过`,
											icon: 'none',
											duration: 2000
										});
										return;
									}

									// 检查文件类型
									const fileName = fileInfo.name || '';
									const fileExt = fileName.substring(fileName.lastIndexOf('.'))
										.toLowerCase();
									const allowedExts = ['.doc', '.docx', '.pdf', '.txt', '.xls',
										'.xlsx', '.ppt', '.pptx'
									];

									if (!allowedExts.includes(fileExt)) {
										uni.showToast({
											title: `文件"${fileInfo.name}"类型不支持，已跳过`,
											icon: 'none',
											duration: 2000
										});
										return;
									}

									// 上传文件
									this.handleFileUpload(fileInfo.path, fileInfo.name);
								});
							}
						},
						fail: (err) => {
							console.error('选择文件失败:', err);
							if (err.errMsg.indexOf('cancel') === -1) {
								uni.showToast({
									title: '选择文件失败',
									icon: 'none'
								});
							}
						}
					});
				} else if (type === 'image' || type === 1) {
					// 上传图片使用常规的图片选择器
					uni.chooseImage({
						count: 10, // 最多选择10张图片
						sizeType: ['original', 'compressed'], // 可选择原图或压缩图
						sourceType: ['album'], // 从相册选择
						success: (res) => {
							if (res.tempFilePaths && res.tempFilePaths.length > 0) {
								// 显示选择的图片数量
								uni.showToast({
									title: `已选择${res.tempFilePaths.length}张图片`,
									icon: 'none',
									duration: 1500
								});

								// 遍历处理每张图片
								res.tempFilePaths.forEach((filePath, index) => {
									const fileName = filePath.substring(filePath.lastIndexOf('/') + 1);

									// 获取当前图片的文件信息
									const fileInfo = res.tempFiles[index];

									// 检查文件大小，限制为10MB
									if (fileInfo && fileInfo.size > 10 * 1024 * 1024) {
										uni.showToast({
											title: `图片大小超过10MB，已跳过`,
											icon: 'none',
											duration: 2000
										});
										return;
									}

									this.handleFileUpload(filePath, fileName);
								});
							}
						},
						fail: (err) => {
							console.error('选择图片失败:', err);
							if (err.errMsg.indexOf('cancel') === -1) {
								uni.showToast({
									title: '选择图片失败',
									icon: 'none'
								});
							}
						}
					});
				}
			},
			// 处理文件上传
			async handleFileUpload(filePath, fileName) {
				try {
					// 获取文件名，如果没有传入fileName，则从filePath中提取
					const uploadFileName = fileName || filePath.substring(filePath.lastIndexOf('/') + 1);

					// 显示上传进度的加载提示
					uni.showLoading({
						title: `正在上传: ${uploadFileName.length > 10 ? uploadFileName.substring(0, 10) + '...' : uploadFileName}`,
						mask: false
					});

					// 使用API上传文件到指定数据集
					const datasetId = uni.getStorageSync('datasetId'); // 数据集ID

					// 调用修改后的uploadDocument方法
					const result = await api.datasets.uploadDocument(filePath,uploadFileName);

					console.log('文件上传结果:', result);
					// 隐藏加载提示
					uni.hideLoading();

					// 显示简短的成功提示
					uni.showToast({
						title: `${uploadFileName.length > 8 ? uploadFileName.substring(0, 8) + '...' : uploadFileName} 上传成功`,
						icon: 'success',
						duration: 1500
					});

					// 刷新文件列表 (延迟刷新，等所有文件上传完成)
					this.$nextTick(() => {
						// 使用防抖处理，避免多次刷新
						if (this.refreshDebounceTimer) {
							clearTimeout(this.refreshDebounceTimer);
						}
						this.refreshDebounceTimer = setTimeout(() => {
							this.refreshFileList();
						}, 1000); // 1秒后刷新列表
					});
				} catch (error) {
					console.error('上传文件失败', error);
					uni.hideLoading();
					// 显示上传失败提示
					const shortName = fileName && fileName.length > 10 ? fileName.substring(0, 10) + '...' : (
						fileName || '文件');
					uni.showToast({
						title: `${shortName}上传失败`,
						icon: 'none',
						duration: 2000
					});
				}
			},
			// 显示删除确认弹窗
			showDeleteConfirm(index) {
				uni.showModal({
					title: '删除文件',
					content: `确定要删除"${this.files[index].name}"吗？`,
					confirmColor: '#f56c6c',
					success: (res) => {
						if (res.confirm) {
							this.handleDeleteFile(index)
						}
					}
				})
			},
			// 处理文件删除
			async handleDeleteFile(index) {
				try {
					uni.showLoading({
						title: '删除中...'
					});

					// 获取要删除的文件信息
					const file = this.files[index];
					if (!file || !file.id) {
						throw new Error('无效的文件信息');
					}

					// 使用数据集ID和文档ID删除文档
					const datasetId = 'b3996ac6048b11f0a3500242ac150006';
					await api.datasets.deleteDocument(datasetId, file.id);

					// 从列表中移除
					this.files.splice(index, 1);

					uni.hideLoading();
					uni.showToast({
						title: '删除成功',
						icon: 'success'
					});
				} catch (error) {
					console.error('删除文件失败', error);
					uni.hideLoading();
					uni.showToast({
						title: '删除失败',
						icon: 'none'
					});
				}
			},

			// 启用多选模式
			enableMultiSelectWithFile(fileId) {
				// 启用多选模式
				this.isMultiSelect = true;
				// 初始化选中的文件ID数组，并添加长按的文件ID
				this.selectedFileIds = fileId ? [fileId] : [];

				// 显示提示
				uni.showToast({
					title: '已进入多选模式',
					icon: 'none',
					duration: 1000
				});
			},

			// 取消多选模式
			cancelMultiSelect() {
				this.isMultiSelect = false;
				this.selectedFileIds = [];
			},

			// 处理文件选择状态变化
			handleFileSelect(fileId) {
				const index = this.selectedFileIds.indexOf(fileId);
				if (index === -1) {
					// 如果不存在，添加到选中列表
					this.selectedFileIds.push(fileId);
				} else {
					// 如果已存在，从选中列表移除
					this.selectedFileIds.splice(index, 1);

					// 如果没有选中的文件了，退出多选模式
					if (this.selectedFileIds.length === 0) {
						this.cancelMultiSelect();
					}
				}
			},

			// 显示批量删除确认弹窗
			showBatchDeleteConfirm() {
				if (this.selectedFileIds.length === 0) {
					uni.showToast({
						title: '请先选择要删除的文件',
						icon: 'none'
					});
					return;
				}

				uni.showModal({
					title: '批量删除文件',
					content: `确定要删除选中的${this.selectedFileIds.length}个文件吗？`,
					confirmColor: '#f56c6c',
					success: (res) => {
						if (res.confirm) {
							this.handleBatchDeleteFiles();
						}
					}
				});
			},

			// 处理批量删除文件
			async handleBatchDeleteFiles() {
				if (this.selectedFileIds.length === 0) return;

				try {
					uni.showLoading({
						title: '批量删除中...'
					});

					const datasetId = 'b3996ac6048b11f0a3500242ac150006';
					await api.datasets.batchDeleteDocuments(datasetId, this.selectedFileIds);

					// 从列表中移除已删除的文件
					this.files = this.files.filter(file => !this.selectedFileIds.includes(file.id));

					// 退出多选模式
					this.cancelMultiSelect();

					uni.hideLoading();
					uni.showToast({
						title: '批量删除成功',
						icon: 'success'
					});
				} catch (error) {
					console.error('批量删除文件失败', error);
					uni.hideLoading();
					uni.showToast({
						title: '批量删除失败',
						icon: 'none'
					});
				}
			},

			async openFile(file) {
				try {
					console.log("打开文件：", file)
					uni.showLoading({
						title: '打开中...',
						mask: true
					});
					const datasetId = uni.getStorageSync('datasetId');

					console.log("文档下载地址：", request)
					console.log("文档下载地址：", request.BASE_URL_V1 + '/api/v1/datasets/' + datasetId + '/documents/' + file
						.id)
					// 下载文件
					request.download(datasetId, file.id).then(resp => {
						console.log("下载文件1.1", resp);
						if (resp) {
							var filePath = null;
							if (Array.isArray(resp)) {
								var filePath = resp[1].tempFilePath;

							} else {
								var filePath = resp.tempFilePath;
							}
							if (filePath) {
								console.log("文件路径", filePath)
								uni.openDocument({
									filePath: filePath,
									showMenu: true,
									success: function(res) {
										console.log('打开文档成功');
									},
									fail(error) {
										console.log("文件打开失败", error)
									}
								});
							}
						}
						uni.hideLoading();

					},()=>{
						uni.showToast({
							title: '下载失败',
							icon: 'none'
						});
					});
					// console.log("下载文件",downloadRes);
				} catch (error) {
					console.error('处理文件时出错:', error);
					uni.showToast({
						title: '操作失败',
						icon: 'none'
					});
					uni.hideLoading();
				}
			}
		}
	}
</script>

<style lang="scss" scoped>
	.knowledge-container {
		background-color: #f5f5f5;
		height: 100vh;
		position: relative;
	}

	.scroll-view {
		height: calc(100% - 120rpx);
	}

	.multi-select-bar {
		position: fixed;
		bottom: 0;
		left: 0;
		right: 0;
		background-color: #fff;
		padding: 10rpx;
		display: flex;
		justify-content: space-between;
		align-items: center;

		.selected-count {
			font-size: 28rpx;
			color: #333;
		}

		.action-btns {
			display: flex;
			gap: 20rpx;

			.cancel-btn,
			.delete-btn {
				padding: 10rpx 20rpx;
				background-color: #f56c6c;
				color: #fff;
				border: none;
				border-radius: 4rpx;
				font-size: 28rpx;
				cursor: pointer;

				&:hover {
					background-color: #f78989;
				}
			}

			.cancel-btn {
				background-color: #909399;

				&:hover {
					background-color: #a6a9ad;
				}
			}
		}
	}
</style>